package com.company;

import org.jetbrains.annotations.NotNull;

public class LineSearch {
    private LineSearch() {
    }

    //静态函数 Math
    //泛型方法
    // public static <> int 方法
    // byte boole string int long float double
    public static <E> int search(E @NotNull [] data, E target) {
        if (data.length <= 0) return -1;
        for (int i = 0; i < data.length; i++)
            if (data[i].equals(target))
                return i;
        return -1;
    }

    public static void main(String[] args) {
        int[] dataSize = {1000000, 10000000};
        for (int n : dataSize) {
            Integer[] data = ArrayGenerator.generateOrderedArray(n);
            long startTime = System.nanoTime();//纳秒的时间戳
            for (int k = 0; k < 100; k++)
                LineSearch.search(data, n);
            long endTime = System.nanoTime();
            double time = (endTime - startTime) / 1000000000.0;
            System.out.println("n = " + n + ", 100 runs: " + time + "s");
        }
        //线性增长 线性增长 性能也是十倍左右的
        // o 1 < o logn < 更好的 n<n<nlong<n2<n2<n!
        //线性的增长的方式
        //在正常的方式和测试优化方式都是可以的
        //本章的总结
        //线性查找方法
        //学习使用泛型的方法
        //泛型的类
        //泛型的方法
        // static E 方法本身 equals实现
        //循环不变量的方式 在
        //如何编写正确的 循环不变量
        //复杂度分析
        //测试算法性能
        //泛型方法 泛型类
        //算法设计 循环不变量
        //每一个算法复杂度分析
        //但是其他的内容需要处理本身的数据结构和算法
        //查找法 排序法
        //很多的 设计方式
        //基础的排序算法
        //排序苏娜发 让数据有序
        //排序算法中蕴含中重要的算法设计思想
        //选择排序法
        //插入排序法
        //高级排序+插入排序法+优化+迭代
        //选择排序法
        //先把最小的拿出来
        //剩下的在把最小的拿出来
        //剩下的在把最小的拿出来
        //每次都是选择还没处理的元素了；哦最小的元素
        //最小瓶的 最小的 刓 取出  1
        //再次拿出 拿出来
        // 1 2 3 4 5 6
        //设计思路就是从小到大的方式进行选择排序
        //都是最小的方式 系哦啊哟西按到老、
        //懂最大的方式都是从打到校的方式
        //其实额外的空间 数组
        //新开辟的数组 在每轮 的数组 排序的暂用的了额外的空间
        //其实就是可以在原地交换的方式
        //排序过程可以不可以原地的排序的方式
        //额外的空间+可以原地的排序的宣发
        //原地 排序方式
        //数据接口和算法
        //Javailable
        //Go+Python的方式
        //类设计的方式
        //可以这样的方式去做
        // i=0 的方式 很显然
        // minIndex 记录1所在的位置
        // minIndex 1和6交换位置
        //i=0 等于 minIndex
        // i++ arr[i...n]还没排序arr[0...i]排序过了
        // arr[i]放在arr[i]位置
        //arr[1..n]
        //arr[0]=1
        //arr[1]=2
        //arr[2]=4
        //arr[2..n]
        //arr[2]=3
        //arr[3]=4
        //arr[3]=4
        //arr[4]=5
        //arr[5]=6
        //arri minIndex 自己和自己交换位置
        //排序的方式
        //数据结构和算法
        //每轮方式 保证 arr[i..n]未排序arr[0..i]【排序好的
        //arr[i..n]的最小智要放到平 arr[i]的位置
        //不端的维持循环补年报 arr[i..i] arr[0..i]
        // arr[n..n] 选择【排序 循环不变量

    }
}
